#pragma once

#include "system/trading_system.h"
#include "strategy/optimized_strategy_factory.h"
#include "utils/memory_pool.h"
#include "utils/ring_buffer.h"
#include "utils/simd_math.h"
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>
#include <queue>
#include <mutex>
#include <atomic>
#include <thread>
#include <condition_variable>
#include <chrono>

namespace hft {

/**
 * @brief 优化的交易系统类
 * 
 * 这个类是整个高频交易系统的核心，负责管理市场数据、订单处理和策略执行。
 * 它使用内存池、无锁队列和SIMD优化来提高性能。
 */
class OptimizedTradingSystem : public TradingSystem {
public:
    /**
     * @brief 构造函数
     * @param config_file 配置文件路径
     */
    explicit OptimizedTradingSystem(const std::string& config_file = "")
        : TradingSystem(config_file)
        , market_data_pool_(10000)
        , order_pool_(1000)
        , market_data_buffer_(10000)
        , is_running_(false)
        , market_data_count_(0)
        , order_count_(0)
        , last_performance_log_(0)
        , performance_log_interval_(10000)  // 每10000个市场数据记录一次性能
    {
        // 检测SIMD支持级别
        simd_level_ = utils::simd::getSimdLevel();
        LOG(INFO) << "创建优化交易系统, SIMD支持级别: " << getSimdLevelString();
    }

    /**
     * @brief 析构函数
     */
    ~OptimizedTradingSystem() {
        stop();
    }

    /**
     * @brief 启动交易系统
     */
    void start() override {
        if (is_running_) return;
        
        LOG(INFO) << "启动优化交易系统";
        is_running_ = true;
        
        // 启动工作线程
        market_data_thread_ = std::thread(&OptimizedTradingSystem::processMarketDataThread, this);
        order_thread_ = std::thread(&OptimizedTradingSystem::processOrderThread, this);
        
        // 启动所有策略
        OptimizedStrategyFactory::getInstance().startAllStrategies();
        
        TradingSystem::start();
    }

    /**
     * @brief 停止交易系统
     */
    void stop() override {
        if (!is_running_) return;
        
        LOG(INFO) << "停止优化交易系统";
        is_running_ = false;
        
        // 停止所有策略
        OptimizedStrategyFactory::getInstance().stopAllStrategies();
        
        // 通知工作线程退出
        market_data_cv_.notify_all();
        order_cv_.notify_all();
        
        // 等待工作线程结束
        if (market_data_thread_.joinable()) {
            market_data_thread_.join();
        }
        
        if (order_thread_.joinable()) {
            order_thread_.join();
        }
        
        TradingSystem::stop();
    }

    /**
     * @brief 处理市场数据
     * @param data 市场数据
     */
    void processMarketData(const MarketData& data) override {
        if (!is_running_) return;
        
        // 使用对象池分配MarketData对象的副本
        auto* data_copy = market_data_pool_.create(data);
        
        // 添加到市场数据缓冲区
        {
            std::lock_guard<std::mutex> lock(market_data_mutex_);
            market_data_buffer_.push_back(data_copy);
        }
        
        // 通知工作线程处理新数据
        market_data_cv_.notify_one();
        
        // 增加计数器
        ++market_data_count_;
        
        // 定期记录性能
        auto current_count = market_data_count_.load();
        if (current_count - last_performance_log_ >= performance_log_interval_) {
            last_performance_log_ = current_count;
            logPerformance();
        }
    }

    /**
     * @brief 处理订单
     * @param order 订单
     */
    void processOrder(const Order& order) override {
        if (!is_running_) return;
        
        // 使用对象池分配Order对象的副本
        auto* order_copy = order_pool_.create(order);
        
        // 添加到订单队列
        {
            std::lock_guard<std::mutex> lock(order_mutex_);
            order_queue_.push(order_copy);
        }
        
        // 通知工作线程处理新订单
        order_cv_.notify_one();
        
        // 增加计数器
        ++order_count_;
    }

    /**
     * @brief 获取系统状态
     * @return 系统状态的JSON字符串
     */
    std::string getState() const override {
        nlohmann::json state = nlohmann::json::parse(TradingSystem::getState());
        
        // 添加优化系统特有的状态信息
        state["is_running"] = is_running_;
        state["simd_level"] = getSimdLevelString();
        state["market_data_count"] = market_data_count_.load();
        state["order_count"] = order_count_.load();
        
        // 添加内存池统计信息
        auto [market_data_allocated, market_data_freed] = market_data_pool_.getStats();
        auto [order_allocated, order_freed] = order_pool_.getStats();
        
        state["memory_pool"] = {
            {"market_data_allocated", market_data_allocated},
            {"market_data_freed", market_data_freed},
            {"market_data_active", market_data_allocated - market_data_freed},
            {"order_allocated", order_allocated},
            {"order_freed", order_freed},
            {"order_active", order_allocated - order_freed},
            {"market_data_blocks", market_data_pool_.getBlockCount()},
            {"order_blocks", order_pool_.getBlockCount()}
        };
        
        // 添加策略状态
        state["strategies"] = nlohmann::json::parse(OptimizedStrategyFactory::getInstance().getStatusReport());
        
        return state.dump(4);
    }

    /**
     * @brief 清理未使用的内存
     */
    void shrinkMemoryPools() {
        market_data_pool_.shrink();
        order_pool_.shrink();
        OptimizedStrategyFactory::getInstance().shrinkMemoryPools();
        LOG(INFO) << "清理未使用的内存池";
    }

    /**
     * @brief 创建均值回归策略
     * @param symbol 交易品种
     * @param window_size 移动平均窗口大小
     * @param entry_threshold 入场阈值
     * @param exit_threshold 出场阈值
     * @return 策略指针
     */
    std::shared_ptr<OptimizedMeanReversionStrategy> createMeanReversionStrategy(
        const std::string& symbol,
        size_t window_size = 20,
        double entry_threshold = 2.0,
        double exit_threshold = 0.5) {
        
        auto strategy = OptimizedStrategyFactory::getInstance().createMeanReversionStrategy(
            symbol, window_size, entry_threshold, exit_threshold);
        
        // 设置交易系统
        strategy->setTradingSystem(this);
        
        return strategy;
    }

    /**
     * @brief 创建统计套利策略
     * @param symbol1 第一个交易品种
     * @param symbol2 第二个交易品种
     * @param window_size 计算窗口大小
     * @param entry_threshold 入场阈值
     * @param exit_threshold 出场阈值
     * @return 策略指针
     */
    std::shared_ptr<OptimizedStatisticalArbitrageStrategy> createStatisticalArbitrageStrategy(
        const std::string& symbol1,
        const std::string& symbol2,
        size_t window_size = 100,
        double entry_threshold = 2.0,
        double exit_threshold = 0.5) {
        
        auto strategy = OptimizedStrategyFactory::getInstance().createStatisticalArbitrageStrategy(
            symbol1, symbol2, window_size, entry_threshold, exit_threshold);
        
        // 设置交易系统
        strategy->setTradingSystem(this);
        
        return strategy;
    }

private:
    /**
     * @brief 市场数据处理线程
     */
    void processMarketDataThread() {
        LOG(INFO) << "启动市场数据处理线程";
        
        while (is_running_) {
            std::vector<MarketData*> batch;
            
            // 获取一批市场数据
            {
                std::unique_lock<std::mutex> lock(market_data_mutex_);
                market_data_cv_.wait_for(lock, std::chrono::milliseconds(100), 
                    [this] { return !is_running_ || !market_data_buffer_.empty(); });
                
                if (!is_running_ && market_data_buffer_.empty()) {
                    break;
                }
                
                // 获取所有可用的市场数据
                while (!market_data_buffer_.empty()) {
                    batch.push_back(market_data_buffer_.front());
                    market_data_buffer_.pop_front();
                }
            }
            
            // 处理这批市场数据
            for (auto* data : batch) {
                try {
                    // 获取所有策略
                    auto strategies = OptimizedStrategyFactory::getInstance().getAllStrategies();
                    
                    // 将市场数据分发给所有策略
                    for (auto& strategy : strategies) {
                        strategy->onMarketData(*data);
                    }
                    
                } catch (const std::exception& e) {
                    LOG(ERROR) << "处理市场数据时发生错误: " << e.what();
                }
                
                // 释放市场数据对象
                market_data_pool_.destroy(data);
            }
        }
        
        LOG(INFO) << "市场数据处理线程结束";
    }

    /**
     * @brief 订单处理线程
     */
    void processOrderThread() {
        LOG(INFO) << "启动订单处理线程";
        
        while (is_running_) {
            std::vector<Order*> batch;
            
            // 获取一批订单
            {
                std::unique_lock<std::mutex> lock(order_mutex_);
                order_cv_.wait_for(lock, std::chrono::milliseconds(100), 
                    [this] { return !is_running_ || !order_queue_.empty(); });
                
                if (!is_running_ && order_queue_.empty()) {
                    break;
                }
                
                // 获取所有可用的订单
                while (!order_queue_.empty()) {
                    batch.push_back(order_queue_.front());
                    order_queue_.pop();
                }
            }
            
            // 处理这批订单
            for (auto* order : batch) {
                try {
                    // 处理订单（实际交易逻辑）
                    processOrderInternal(*order);
                    
                    // 获取所有策略
                    auto strategies = OptimizedStrategyFactory::getInstance().getAllStrategies();
                    
                    // 将订单更新分发给所有策略
                    for (auto& strategy : strategies) {
                        strategy->onOrderUpdate(*order);
                    }
                    
                } catch (const std::exception& e) {
                    LOG(ERROR) << "处理订单时发生错误: " << e.what();
                }
                
                // 释放订单对象
                order_pool_.destroy(order);
            }
        }
        
        LOG(INFO) << "订单处理线程结束";
    }

    /**
     * @brief 内部订单处理逻辑
     * @param order 订单
     */
    void processOrderInternal(Order& order) {
        // 这里是实际的订单处理逻辑
        // 在实际系统中，这里会与交易所API交互
        
        // 模拟订单处理
        order.status = OrderStatus::FILLED;
        order.filled_quantity = order.quantity;
        order.filled_price = order.price;
        
        LOG(INFO) << "订单已处理: " << order.symbol 
                  << " " << (order.direction == OrderDirection::BUY ? "买入" : "卖出")
                  << " " << order.quantity
                  << " @ " << order.price;
    }

    /**
     * @brief 记录性能统计
     */
    void logPerformance() {
        auto [market_data_allocated, market_data_freed] = market_data_pool_.getStats();
        auto [order_allocated, order_freed] = order_pool_.getStats();
        
        LOG(INFO) << "性能统计: "
                  << "市场数据=" << market_data_count_.load()
                  << ", 订单=" << order_count_.load()
                  << ", 市场数据池使用率=" << (market_data_allocated - market_data_freed) * 100.0 / market_data_allocated << "%"
                  << ", 订单池使用率=" << (order_allocated - order_freed) * 100.0 / (order_allocated > 0 ? order_allocated : 1) << "%";
    }

    /**
     * @brief 获取SIMD支持级别的字符串表示
     * @return SIMD支持级别字符串
     */
    std::string getSimdLevelString() const {
        switch (simd_level_) {
            case utils::simd::SimdLevel::AVX: return "AVX";
            case utils::simd::SimdLevel::SSE4_1: return "SSE4.1";
            case utils::simd::SimdLevel::SSE3: return "SSE3";
            case utils::simd::SimdLevel::SSE2: return "SSE2";
            default: return "None";
        }
    }

private:
    utils::MemoryPool<MarketData> market_data_pool_;       // 市场数据对象池
    utils::MemoryPool<Order> order_pool_;                  // 订单对象池
    utils::RingBuffer<MarketData*> market_data_buffer_;    // 市场数据缓冲区
    std::queue<Order*> order_queue_;                       // 订单队列
    
    std::thread market_data_thread_;                       // 市场数据处理线程
    std::thread order_thread_;                             // 订单处理线程
    std::mutex market_data_mutex_;                         // 市场数据互斥锁
    std::mutex order_mutex_;                               // 订单互斥锁
    std::condition_variable market_data_cv_;               // 市场数据条件变量
    std::condition_variable order_cv_;                     // 订单条件变量
    
    std::atomic<bool> is_running_;                         // 是否正在运行
    std::atomic<uint64_t> market_data_count_;              // 市场数据计数
    std::atomic<uint64_t> order_count_;                    // 订单计数
    std::atomic<uint64_t> last_performance_log_;           // 上次性能日志时间
    uint64_t performance_log_interval_;                    // 性能日志间隔
    
    utils::simd::SimdLevel simd_level_;                    // SIMD支持级别
};

} // namespace hft